// 存储浏览信息的对象
let browsingData = {
  pageVisits: [],
};

// 后端API地址 - 现在通过declarativeNetRequest重定向
// const API_BASE_URL = "https://api.ecom-pilot.ai";

// 监听来自popup或content script的消息
chrome.runtime.onMessage.addListener(function(message, sender, sendResponse) {
  console.log('后台脚本收到消息:', message);
  
  if (message.action === 'send_chat_message') {
    // 处理从侧边栏发送过来的聊天请求
    console.log("准备向后端发送聊天消息:", message.data);
    streamChat('/chat', message.data);
    sendResponse({ success: true, message: "已开始处理流式请求" });
    // 这里是异步操作的起点，返回true
    return true; 
  }
  
  if (message.action === 'resume_chat_stream') {
      console.log("准备恢复后端聊天流:", message.data);
      streamChat('/chat/resume', message.data);
      sendResponse({ success: true, message: "已开始处理恢复请求" });
      return true;
  }
  
  if (message.action === 'execute_tool') {
      console.log(`请求执行工具: ${message.tool_name}`);
      // 使用async/await来处理异步工具执行
      (async () => {
          try {
              const output = await handleToolExecution(message.tool_name, message.tool_args);
              sendResponse({ success: true, output: output });
          } catch (error) {
              console.error(`执行工具 ${message.tool_name} 失败:`, error);
              sendResponse({ success: false, error: error.message });
          }
      })();
      return true; // 必须返回true，因为我们是异步响应
  }
  
  // 处理页面信息
  if (message.action === 'pageInfo') {
    const timestamp = new Date().toISOString();
    const pageInfo = {
      ...message.data,
      timestamp,
      tabId: sender.tab ? sender.tab.id : 'popup'
    };
    
    // 添加到浏览历史
    browsingData.pageVisits.push(pageInfo);
    
    // 限制存储的历史记录数量
    if (browsingData.pageVisits.length > 50) {
      browsingData.pageVisits.shift();
    }
    
    // 将数据保存到本地存储
    chrome.storage.local.set({ browsingData });
    
    // 打印调试信息
    console.log('已记录页面信息:', pageInfo);
    console.log('当前浏览历史:', browsingData.pageVisits);
    sendResponse({ success: true }); // 同步发送响应
  }
  
  // 处理来自content script的页面分析数据
  if (message.action === 'pageAnalysis') {
    console.log('收到页面分析数据:', message.data);
    
    // 这里可以进一步处理页面分析数据
    // 例如，将其发送到服务器或进行本地分析
  }
  
  // 对于其他未处理的消息，不返回任何内容（即undefined），表示同步处理完成
});

async function streamChat(endpoint, body) {
  const fullUrl = `https://api.ecom-pilot.ai/api${endpoint}`;
  console.log(`Fetching from: ${fullUrl}`); // 添加日志，确认URL

  try {
    const response = await fetch(fullUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'text/event-stream'
      },
      body: JSON.stringify(body)
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const reader = response.body.getReader();
    const decoder = new TextDecoder("utf-8");
    let buffer = '';

    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        console.log("SSE 流结束");
        // 不再由前端发送完成信号，完全依赖后端的 'conversation_end' 消息
        break;
      }
      
      buffer += decoder.decode(value, { stream: true });
      
      // 按行处理缓冲区中的数据
      const lines = buffer.split('\n');
      buffer = lines.pop(); // 保留不完整的最后一行

      for (const line of lines) {
        if (line.startsWith('data: ')) {
          const data = line.substring(6).trim();
          if (data) {
            handleSSEData(data, body.session_id);
          }
        }
      }
    }

  } catch (error) {
    console.error("请求或处理SSE流时出错:", error);
    // 向侧边栏发送错误信息
    chrome.runtime.sendMessage({
      type: "error",
      content: `与后端通信时发生错误: ${error.message}`
    }).catch(e => console.error("发送错误信息到侧边栏失败:", e));
  }
}

async function handleSSEData(jsonData, sessionId) {
  console.log("收到 SSE 数据:", jsonData);
  try {
    const message = JSON.parse(jsonData);

    // 核心修复：根据消息类型进行正确处理或转发
    if (message.type === 'chat_response' || message.type === 'message_chunk') {
        // 将消息转发到侧边栏，保持类型为 'chat_response'
      chrome.runtime.sendMessage({
        type: 'chat_response',
        content: message.content
      }).catch(error => {
        if (error.message.includes("Could not establish connection.")) {
          console.warn("侧边栏未打开，无法发送消息。");
        } else {
          console.error("发送消息到侧边栏时出错:", error);
        }
      });
    } else if (message.type === 'tool_auto_execution_request') {
        // 这是后台的内部处理流程，不直接转发原始消息
        console.log("收到自动执行请求:", message.payload);
        
        // 1. 通知侧边栏，AI即将自动执行操作
      chrome.runtime.sendMessage({
            type: 'tool_auto_execution_started',
            payload: message.payload
        });

        // 2. 异步执行工具并恢复工作流
        const toolCalls = message.payload.tool_calls;
        const toolOutputs = [];
        
        for (const call of toolCalls) {
            let output;
            try {
                const result = await handleToolExecution(call.name, call.args);
                output = JSON.stringify(result);
            } catch (error) {
                console.error(`工具 ${call.name} 自动执行失败:`, error);
                output = JSON.stringify({ success: false, error: error.message });
            }
            toolOutputs.push({ tool_call_id: call.id, output: output });
        }
        
        console.log("工具自动执行完成，准备恢复工作流:", toolOutputs);
        // 3. 将结果发回后端以恢复工作流
        streamChat('/chat/resume', { 
            session_id: sessionId, 
            tool_outputs: toolOutputs 
        });
    } else {
        // 对于其他所有类型的消息 (如 tool_approval_request, conversation_end, error)，直接转发
      chrome.runtime.sendMessage(message).catch(error => {
        if (error.message.includes("Could not establish connection.")) {
                console.warn("侧边栏未打开，无法发送消息:", message.type);
        } else {
                console.error(`发送消息 ${message.type} 到侧边栏时出错:`, error);
        }
      });
    }

  } catch (e) {
    console.error("解析或处理 SSE 数据时出错:", e, "原始数据:", jsonData);
  }
}

function handleToolCommand(command) {
    if (!command.action) {
        console.error("收到的命令没有'action'字段:", command);
        return;
    }
    
    console.log(`处理命令: ${command.action}`);
    
    switch(command.action) {
        case 'navigate':
            const url = command.payload?.url;
            if (url) {
                console.log(`执行导航到: ${url}`);
                chrome.tabs.create({ url: url });
            } else {
                console.error("导航命令缺少'url'参数:", command.payload);
            }
            break;
        
        // 在这里可以添加其他命令的处理
        // case 'show_notification':
        //   ...
        //   break;
        
        default:
            console.warn(`未知的命令类型: ${command.action}`);
    }
}

async function handleToolExecution(toolName, toolArgs) {
    console.log(`执行工具: ${toolName}，参数:`, toolArgs);
    let result;
    
    try {
    switch(toolName) {
        case 'navigate_to_url':
            const url = toolArgs?.url;
            if (!url) throw new Error("导航命令缺少'url'参数");
            
            console.log(`执行导航到: ${url}`);
            await chrome.tabs.create({ url: url });

                result = {
                "action": "navigate",
                "payload": { "url": url },
                    "success": true 
                };
                break;
            
            case 'click':
                const selector = toolArgs?.selector;
                if (!selector) throw new Error("点击命令缺少'selector'参数");

                console.log(`执行点击操作，选择器: ${selector}`);
                
                const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
                if (!tab) throw new Error("没有找到活动标签页");

                const results = await chrome.scripting.executeScript({
                    target: { tabId: tab.id },
                    func: (cssSelector) => {
                        const element = document.querySelector(cssSelector);
                        if (element) {
                            element.click();
                            return { success: true, clickedElement: cssSelector };
                        } else {
                            return { success: false, error: `没有找到选择器为'${cssSelector}'的元素` };
                        }
                    },
                    args: [selector]
                });
                
                const scriptResult = results[0].result;
                if (!scriptResult.success) {
                    throw new Error(scriptResult.error);
                }

                result = {
                    action: "click",
                    payload: { selector: selector },
                    success: true,
                    message: `成功点击元素: ${selector}`
                };
                break;
        
        default:
                throw new Error(`未知的工具命令: ${toolName}`);
    }
    } catch (error) {
        console.error(`handleToolExecution 中捕获到错误 for ${toolName}:`, error);
        // 确保即使在执行失败时也返回一个标准的错误结果
        result = { success: false, error: error.message };
    }
    
    // 统一汇报工具执行结果给侧边栏
    chrome.runtime.sendMessage({
        type: 'tool_result_reported',
        data: {
            name: toolName,
            args: toolArgs,
            result: result
        }
    }).catch(e => console.warn("向侧边栏汇报工具结果失败:", e));

    return result;
}

// 初始化时从存储中加载数据
chrome.runtime.onInstalled.addListener(function() {
  chrome.storage.local.get('browsingData', function(result) {
    if (result.browsingData) {
      browsingData = result.browsingData;
      console.log('已从存储加载浏览数据:', browsingData);
    } else {
      console.log('未找到存储的浏览数据，使用默认值');
    }
  });
  
  // 设置侧边栏默认启用
  chrome.sidePanel.setOptions({
    enabled: true,
    path: 'sidebar.html'
  });
  
  console.log('E-com Pilot 插件已安装/更新');
});

// 当扩展图标被点击时，打开侧边栏
chrome.action.onClicked.addListener((tab) => {
  chrome.sidePanel.open({ tabId: tab.id });
}); 